// 模块化
(function (){
    // Promise构造函数
    function Promise(excutor){
        console.log( 'Promise构造函数...' );

        // this -> Promise的实例对象
        this.state = 'pending';// 默认的状态
        this.result = undefined;// 默认的结果
        var _this = this;// 缓存this指向
        this.callbacks = [];// 缓存成功和失败的回调函数
        // [
        //     {// item
        //         'fnResolve': function (){},
        //         'fnReject': function (){}
        //     },
        //     {// item
        //         'fnResolve': function (){},
        //         'fnReject': function (){}
        //     },
        //     ...
        // ]

        // resolve函数
        function resolve(resolveVal){
            console.log( 'resolve函数...' );
            // 判断Promise对象的状态
            if (_this.state !== 'pending') {
                // Promise对象已经被修改过了
                return;// 结束执行函数
            }
            // 将Promise对象的状态改变为成功
            _this.state = 'fulfilled';
            // 修改Promise对象的结果
            _this.result = resolveVal;
            // 判断是否有缓存的回调函数
            if (_this.callbacks.length > 0) {
                // 遍历取出所有的成功回调函数并异步执行
                _this.callbacks.forEach(function (item){
                    setTimeout(function (){
                        item.fnResolve(_this.result);
                    })
                })
            }
        }

        // reject函数
        function reject(rejectVal){
            console.log( 'reject函数...' );
            // 判断Promise对象的状态
            if (_this.state !== 'pending') {
                // Promise对象已经被修改过了
                return;// 结束执行函数
            }
            // 将Promise对象的状态改变为失败
            _this.state = 'rejected';
            // 修改Promise对象的结果
            _this.result = rejectVal;
            // 判断是否有缓存的回调函数
            if (_this.callbacks.length > 0) {
                // 遍历取出所有的失败回调函数并异步执行
                _this.callbacks.forEach(function (item){
                    setTimeout(function (){
                        item.fnReject(_this.result);
                    })
                })
            }
        }

        // 调用执行器函数,同步执行
        // 执行器函数内部出现异常时,Promise对象的状态改变为失败
        try {
            excutor(resolve,reject);
        }catch(err){
            reject(err);
        }
    }

    // then方法: 指定Promise对象成功和失败的回调函数,返回一个新的Promise对象
    Promise.prototype.then = function (fnResolve,fnReject){
        // fnResolve 成功的回调函数
        // fnReject 失败的回调函数
        console.log( 'then方法...' );

        // this -> Promise实例对象
        var _this = this;// 缓存this指向

        // 返回一个新的Promise对象 -> p2
        return new Promise(function (resolve,reject){
            // 成功和失败回调函数的处理程序
            function handle(callback){
                try {
                    // result 是成功回调函数的返回值
                    var result = callback(_this.result);
                    
                    if (result instanceof Promise) {
                        // result 为Promise对象
                        // result是Promise对象时,p2的状态和结果跟随result的状态和结果
                        result.then(
                            (res)=>{
                                resolve(res);
                            },
                            (res)=>{
                                reject(res);
                            }
                        );
                        // result.then(resolve,reject);
                    }
                    else {
                        // result 为非Promise对象
                        resolve(result);
                    }
                }catch(err){
                    // 异常情况,p2为失败状态,结果为异常信息
                    reject(err);
                }
            }
            // 判断Promise对象的状态
            if (_this.state === 'fulfilled') {
                // fnResolve异步执行
                setTimeout(function (){
                    handle(fnResolve);
                });
            }
            if (_this.state === 'rejected') {
                // fnReject异步执行
                setTimeout(function (){
                    handle(fnReject);
                });
            }
            if (_this.state === 'pending') {
                // 缓存成功和失败的回调函数
                _this.callbacks.push({
                    // 'fnResolve': fnResolve,
                    // 'fnReject': fnReject
                    'fnResolve': function (){
                        handle(fnResolve);
                    },
                    'fnReject': function (){
                        handle(fnReject);
                    }
                });
            }
        });
    }

    // catch方法
    Promise.prototype.catch = function (){
        
    }

    // resolve静态方法
    Promise.resolve = function (){

    }

    // reject静态方法
    Promise.reject = function (){
        
    }

    // 对外暴露Promise函数(覆盖原来的Promise函数)
    window.Promise = Promise;
})();
